home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / sstring.c < prev    next >
C/C++ Source or Header  |  1997-04-13  |  10KB  |  436 lines
  1. /* Copyright (C) 1993, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* sstring.c */
  20. /* String and hexstring streams (filters) */
  21. #include "stdio_.h"        /* includes std.h */
  22. #include "memory_.h"
  23. #include "string_.h"
  24. #include "strimpl.h"
  25. #include "sstring.h"
  26. #include "scanchar.h"
  27.  
  28. /* ------ ASCIIHexEncode ------ */
  29.  
  30. /* Process a buffer */
  31. private int
  32. s_AXE_process(stream_state *st, stream_cursor_read *pr,
  33.   stream_cursor_write *pw, bool last)
  34. {    register const byte *p = pr->ptr;
  35.     register byte *q = pw->ptr;
  36.     int rcount = pr->limit - p;
  37.     int wcount = pw->limit - q;
  38.     register int count;
  39.     register const char _ds *hex_digits = "0123456789abcdef";
  40.     int status = 0;
  41.  
  42.     if ( last )
  43.       wcount--;            /* leave room for '>' */
  44.     wcount -= (wcount + 64) / 65;    /* leave room for \n */
  45.     wcount >>= 1;            /* 2 chars per input byte */
  46.     count = (wcount < rcount ? (status = 1, wcount) : rcount);
  47.     while ( --count >= 0 )
  48.     {    *++q = hex_digits[*++p >> 4];
  49.         *++q = hex_digits[*p & 0xf];
  50.         if ( !(count & 31) && (count != 0 || !last) )
  51.           *++q = '\n';
  52.     }
  53.     if ( last && status == 0 )
  54.       *++q = '>';
  55.     pr->ptr = p;
  56.     pw->ptr = q;
  57.     return status;
  58. }
  59.  
  60. /* Stream template */
  61. const stream_template s_AXE_template =
  62. {    &st_stream_state, NULL, s_AXE_process, 1, 3
  63. };
  64.  
  65. /* ------ ASCIIHexDecode ------ */
  66.  
  67. private_st_AXD_state();
  68.  
  69. #define ss ((stream_AXD_state *)st)
  70.  
  71. /* Initialize the state */
  72. private int
  73. s_AXD_init(stream_state *st)
  74. {    return s_AXD_init_inline(ss);
  75. }
  76.  
  77. /* Process a buffer */
  78. private int
  79. s_AXD_process(stream_state *st, stream_cursor_read *pr,
  80.   stream_cursor_write *pw, bool last)
  81. {    int code = s_hex_process(pr, pw, &ss->odd, hex_ignore_whitespace);
  82.     switch ( code )
  83.     {
  84.     case 0:
  85.         if ( ss->odd >= 0 && last )
  86.         {    if ( pw->ptr == pw->limit )
  87.               return 1;
  88.             *++(pw->ptr) = ss->odd << 4;
  89.         }
  90.         /* falls through */
  91.     case 1:
  92.         /* We still need to read ahead and check for EOD. */
  93.         for ( ; pr->ptr < pr->limit; pr->ptr++ )
  94.           if ( scan_char_decoder[pr->ptr[1]] != ctype_space )
  95.             { if ( pr->ptr[1] == '>' )
  96.             { pr->ptr++;
  97.               goto eod;
  98.             }
  99.               return 1;
  100.             }
  101.         return 0;    /* still need to scan ahead */
  102.     default:
  103.         return code;
  104.     case ERRC:
  105.         ;
  106.     }
  107.     /*
  108.      * Check for EOD.  ERRC implies at least one more character
  109.      * was read; we must unread it, since the caller might have
  110.      * invoked the filter with exactly the right count to read all
  111.      * the available data, and we might be reading past the end.
  112.      */
  113.     if ( *pr->ptr != '>' )        /* EOD */
  114.       { --(pr->ptr);
  115.         return ERRC;
  116.       }
  117. eod:    if ( ss->odd >= 0 )
  118.       { if ( pw->ptr == pw->limit )
  119.           return 1;
  120.         *++(pw->ptr) = ss->odd << 4;
  121.       }
  122.     return EOFC;
  123. }
  124.  
  125. #undef ss
  126.  
  127. /* Stream template */
  128. const stream_template s_AXD_template =
  129. {    &st_AXD_state, s_AXD_init, s_AXD_process, 2, 1
  130. };
  131.  
  132. /* ------ PSStringEncode ------ */
  133.  
  134. /* Process a buffer */
  135. private int
  136. s_PSSE_process(stream_state *st, stream_cursor_read *pr,
  137.   stream_cursor_write *pw, bool last)
  138. {    register const byte *p = pr->ptr;
  139.     const byte *rlimit = pr->limit;
  140.     register byte *q = pw->ptr;
  141.     byte *wlimit = pw->limit;
  142.     int status = 0;
  143.     /* This doesn't have to be very efficient. */
  144.     while ( p < rlimit )
  145.       {    register int c = *++p;
  146.         if ( c < 32 || c >= 127 )
  147.           {    const char *pesc;
  148.             const char *esc = "\n\r\t\b\f";
  149.             if ( c < 32 && c != 0 && (pesc = strchr(esc, c)) != 0 )
  150.               { if ( wlimit - q < 2 )
  151.                   { --p;
  152.                 status = 1;
  153.                 break;
  154.                   }
  155.                 *++q = '\\';
  156.                 *++q = "nrtbf"[pesc - esc];
  157.                 continue;
  158.               }
  159.             if ( wlimit - q < 4 )
  160.               { --p;
  161.                 status = 1;
  162.                 break;
  163.               }
  164.             q[1] = '\\';
  165.             q[2] = (c >> 6) + '0';
  166.             q[3] = ((c >> 3) & 7) + '0';
  167.             q[4] = (c & 7) + '0';
  168.             q += 4;
  169.             continue;
  170.           }
  171.         else if ( c == '(' || c == ')' || c == '\\' )
  172.           {    if ( wlimit - q < 2 )
  173.               { --p;
  174.                 status = 1;
  175.                 break;
  176.               }
  177.             *++q = '\\';
  178.           }
  179.         else
  180.           {    if ( q == wlimit )
  181.               { --p;
  182.                 status = 1;
  183.                 break;
  184.               }
  185.           }
  186.         *++q = c;
  187.       }
  188.     if ( last && status == 0 )
  189.       {    if ( q == wlimit )
  190.           status = 1;
  191.         else
  192.           *++q = ')';
  193.       }
  194.     pr->ptr = p;
  195.     pw->ptr = q;
  196.     return status;
  197. }
  198.  
  199. /* Stream template */
  200. const stream_template s_PSSE_template =
  201. {    &st_stream_state, NULL, s_PSSE_process, 1, 4
  202. };
  203.  
  204. /* ------ PSStringDecode ------ */
  205.  
  206. private_st_PSSD_state();
  207.  
  208. #define ss ((stream_PSSD_state *)st)
  209.  
  210. /* Initialize the state */
  211. private int
  212. s_PSSD_init(stream_state *st)
  213. {    return s_PSSD_init_inline(ss);
  214. }
  215.  
  216. /* Process a buffer */
  217. private int
  218. s_PSSD_process(stream_state *st, stream_cursor_read *pr,
  219.   stream_cursor_write *pw, bool last)
  220. {    register const byte *p = pr->ptr;
  221.     const byte *rlimit = pr->limit;
  222.     register byte *q = pw->ptr;
  223.     byte *wlimit = pw->limit;
  224.     int status = 0;
  225.     register int c;
  226. #define check_p(n)\
  227.   if ( p == rlimit ) { p -= n; goto out; }
  228. #define check_q(n)\
  229.   if ( q == wlimit ) { p -= n; status = 1; goto out; }
  230.     while ( p < rlimit )
  231.       {    c = *++p;
  232.         if ( c == '\\' && !ss->from_string )
  233.           {    check_p(1);
  234.             switch ( (c = *++p) )
  235.             {
  236.             case 'n':
  237.                 c = '\n';
  238.                 goto put;
  239.             case 'r':
  240.                 c = '\r';
  241.                 goto put;
  242.             case 't':
  243.                 c = '\t';
  244.                 goto put;
  245.             case 'b':
  246.                 c = '\b';
  247.                 goto put;
  248.             case 'f':
  249.                 c = '\f';
  250.                 goto put;
  251.             default:        /* ignore the \ */
  252. put:                check_q(2);
  253.                 *++q = c;
  254.                 continue;
  255.             case char_CR:    /* ignore, check for following \n */
  256.                 check_p(2);
  257.                 if ( p[1] == char_EOL )
  258.                     p++;
  259.                 continue;
  260.             case char_EOL:        /* ignore */
  261.                 continue;
  262.             case '0': case '1': case '2': case '3':
  263.             case '4': case '5': case '6': case '7':
  264.               {    int d;
  265.                 check_p(2);
  266.                 d = p[1];
  267.                 c -= '0';
  268.                 if ( d >= '0' && d <= '7' )
  269.                 {    if ( p + 1 == rlimit )
  270.                       {    p -= 2;
  271.                         goto out;
  272.                       }
  273.                     check_q(2);
  274.                     c = (c << 3) + d - '0';
  275.                     d = p[2];
  276.                     if ( d >= '0' && d <= '7' )
  277.                     {    c = (c << 3) + d - '0';
  278.                         p += 2;
  279.                     }
  280.                     else
  281.                         p++;
  282.                 }
  283.                 else
  284.                     check_q(2);
  285.                 *++q = c;
  286.                 continue;
  287.               }
  288.             }
  289.           }
  290.         else
  291.           switch ( c )
  292.         {
  293.         case '(':
  294.             check_q(1);
  295.             ss->depth++;
  296.             break;
  297.         case ')':
  298.             if ( ss->depth == 0 )
  299.               {    status = EOFC;
  300.                 goto out;
  301.               }
  302.             check_q(1);
  303.             ss->depth--;
  304.             break;
  305.         case char_CR:        /* convert to \n */
  306.             check_p(1);
  307.             check_q(1);
  308.             if ( p[1] == char_EOL )
  309.                 p++;
  310.             *++q = '\n';
  311.             continue;
  312.         case char_EOL:
  313.             c = '\n';
  314.         default:
  315.             check_q(1);
  316.             break;
  317.         }
  318.         *++q = c;
  319.       }
  320. #undef check_p
  321. #undef check_q
  322. out:    pr->ptr = p;
  323.     pw->ptr = q;
  324.     if ( last && status == 0 && p != rlimit )
  325.       status = ERRC;
  326.     return status;
  327. }
  328.  
  329. #undef ss
  330.  
  331. /* Stream template */
  332. const stream_template s_PSSD_template =
  333. {    &st_PSSD_state, s_PSSD_init, s_PSSD_process, 4, 1
  334. };
  335.  
  336. /* ------ Utilities ------ */
  337.  
  338. /*
  339.  * Convert hex data to binary.  Return 1 if we filled the string, 0 if
  340.  * we ran out of input data before filling the string, or ERRC on error.
  341.  * The caller must set *odd_digit to -1 before the first call;
  342.  * after each call, if an odd number of hex digits has been read (total),
  343.  * *odd_digit is the odd digit value, otherwise *odd_digit = -1.
  344.  * See strimpl.h for the definition of syntax.
  345.  */
  346. int
  347. s_hex_process(stream_cursor_read *pr, stream_cursor_write *pw,
  348.   int *odd_digit, hex_syntax syntax)
  349. {    const byte *p = pr->ptr;
  350.     const byte *rlimit = pr->limit;
  351.     byte *q = pw->ptr;
  352.     byte *wlimit = pw->limit;
  353.     byte *q0 = q;
  354.     byte val1 = (byte)*odd_digit;
  355.     byte val2;
  356.     uint rcount;
  357.     byte *flimit;
  358.     register const byte _ds *decoder = scan_char_decoder;
  359.     int code = 0;
  360.     if ( q >= wlimit )
  361.       return 1;
  362.     if ( val1 <= 0xf )
  363.       goto d2;
  364. d1:    if ( (rcount = (rlimit - p) >> 1) == 0 )
  365.       goto x1;
  366.     /* Set up a fast end-of-loop check, so we don't have to test */
  367.     /* both p and q against their respective limits. */
  368.     flimit = (rcount < wlimit - q ? q + rcount : wlimit);
  369. f1:    if ( (val1 = decoder[p[1]]) <= 0xf &&
  370.          (val2 = decoder[p[2]]) <= 0xf
  371.        )
  372.     {    p += 2;
  373.         *++q = (val1 << 4) + val2;
  374.         if ( q < flimit )
  375.           goto f1;
  376.         if ( q >= wlimit )
  377.           goto px;
  378.     }
  379. x1:    if ( p >= rlimit )
  380.       goto end1;
  381.     if ( (val1 = decoder[*++p]) > 0xf )
  382.     {    if ( val1 == ctype_space )
  383.           {    switch ( syntax )
  384.               {
  385.               case hex_ignore_whitespace:
  386.                 goto x1;
  387.               case hex_ignore_leading_whitespace:
  388.                 if ( q == q0 && *odd_digit < 0 )
  389.                   goto x1;
  390.                 --p;
  391.                 code = 1;
  392.                 goto end1;
  393.               case hex_ignore_garbage:
  394.                 goto x1;
  395.               }
  396.           }
  397.         else if ( syntax == hex_ignore_garbage )
  398.           goto x1;
  399.         code = ERRC;
  400.         goto end1;
  401.     }
  402. d2:    if ( p >= rlimit )
  403.     {    *odd_digit = val1;
  404.         goto ended;
  405.     }
  406.     if ( (val2 = decoder[*++p]) > 0xf )
  407.     {    if ( val2 == ctype_space )
  408.           switch ( syntax )
  409.           {
  410.           case hex_ignore_whitespace:
  411.             goto d2;
  412.           case hex_ignore_leading_whitespace:
  413.             if ( q == q0 )
  414.               goto d2;
  415.             --p;
  416.             *odd_digit = val1;
  417.             code = 1;
  418.             goto ended;
  419.           case hex_ignore_garbage:    /* pacify compilers */
  420.             ;
  421.           }
  422.         if ( syntax == hex_ignore_garbage )
  423.           goto d2;
  424.         *odd_digit = val1;
  425.         code = ERRC;
  426.         goto ended;
  427.     }
  428.     *++q = (val1 << 4) + val2;
  429.     if ( q < wlimit ) goto d1;
  430. px:    code = 1;
  431. end1:    *odd_digit = -1;
  432. ended:    pr->ptr = p;
  433.     pw->ptr = q;
  434.     return code;
  435. }
  436.